package homework.exp04;

import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.Scanner;
import java.util.Stack;

/**
 * B2类 - 使用栈实现的非递归语法分析器
 * 将递归实现转换为基于栈的非递归实现，避免了深度递归可能导致的栈溢出问题
 */
public class B2 {
    // 输入扫描器，用于读取输入数据
    static Scanner cin = null;

    // 静态初始化块：尝试从文件读取输入，失败则使用标准输入
    static {
        try {
            cin = new Scanner(new FileReader(new File("F.in")));
        } catch (IOException e) {
            cin = new Scanner(System.in);
        }
    }

    /**
     * 主方法：读取每一行输入并调用非递归验证方法
     * @param args 命令行参数
     */
    public static void main(String[] args) {
        while (cin.hasNextLine()) {
            String input = cin.nextLine().trim();
            // 调用非递归版本的验证方法
            if (isValidSentence(input)) {
                System.out.println("YES");
            } else {
                System.out.println("NO");
            }
        }
        cin.close();
    }

    /**
     * 非递归实现的句子验证方法
     * 使用栈来模拟递归调用的过程，避免了深度递归可能导致的栈溢出
     * 栈中存储的是待验证的子句数量
     * 
     * @param input 待验证的输入字符串
     * @return 输入是否为有效的句子
     */
    private static boolean isValidSentence(String input) {
        // 创建栈用于跟踪需要验证的子句数量
        Stack<Integer> stack = new Stack<>();
        // 初始状态：需要验证1个完整句子
        stack.push(1);
        int currentIndex = 0;
        int n = input.length();

        // 逐个字符处理输入
        while (currentIndex < n) {
            // 如果栈为空但仍有字符未处理，则输入无效
            if (stack.isEmpty()) {
                return false;
            }

            // 获取当前字符并前进索引
            char c = input.charAt(currentIndex);
            currentIndex++;

            if (c >= 'p' && c <= 'z') {
                // 处理基础字符(p-z)：这是一个完整的子句
                // 需要更新栈状态，向上传递完成信号
                while (!stack.isEmpty()) {
                    int top = stack.pop() - 1;  // 当前层级需要的子句数减1
                    if (top == 0) {
                        // 当前层级已完成所有子句需求，继续向上处理
                        continue;
                    } else {
                        // 当前层级还需要top个子句，重新压回栈中
                        stack.push(top);
                        break;
                    }
                }
            } else if (c == 'N') {
                // 处理一元运算符N：需要验证1个子句
                stack.push(1);
            } else if (c == 'C' || c == 'D' || c == 'E' || c == 'I') {
                // 处理二元运算符C、D、E、I：需要验证2个子句
                stack.push(2);
            } else {
                // 遇到无效字符，直接返回false
                return false;
            }
        }

        // 所有字符处理完毕后，栈必须为空表示所有需求都已满足
        return stack.isEmpty();
    }
}
